home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994…tember: Reference Library / Dev.CD Sep 94.toast / Periodicals / develop / develop Issue 18 / develop 18 code / Preferences Files / StdPrefsTester.c < prev    next >
Encoding:
Text File  |  1994-03-17  |  20.8 KB  |  862 lines  |  [TEXT/KAHL]

  1. /*
  2.     File:        StdPrefsTester.c
  3.  
  4.     Contains:    Standard preferences library tester routines.
  5.  
  6.                 This test app is just that - a test app.  You should
  7.                 do a LOT more error checking in your own application
  8.                 code!
  9.                 
  10.                 Refer to develop Issue 18, "The Right Way to Implement 
  11.                 Preferences Files", for additional details on this code.
  12.                 
  13.     Written by:    Gary Woodcock
  14.  
  15.     Copyright:    © 1993-94 by Apple Computer, Inc.
  16.  
  17.     Change History (most recent first):
  18.     
  19.                   3/3/94    Version 1.0.
  20.     
  21.     Notes:         This code uses Apple's Universal Interfaces for C.
  22.     
  23.                 Send bug reports to Gary Woodcock at AOL: gwoodcock
  24.                 or Internet: gwoodcock@aol.com.
  25. */
  26.  
  27. //-----------------------------------------------------------------------
  28. // Includes
  29.  
  30. #include "StdPrefsTester.h"
  31. #include "CompileFlags.h"
  32.  
  33. #include "StdPrefsLib.h"
  34.  
  35. #include <Desk.h>
  36. #include <Dialogs.h>
  37. #include <Errors.h>
  38. #include <Fonts.h>
  39. #include <GestaltEqu.h>
  40. #include <Menus.h>
  41. #include <Memory.h>
  42. #include <OSEvents.h>
  43. #include <Packages.h>
  44. #include <QuickDraw.h>
  45. #include <Resources.h>
  46. #include <ToolUtils.h>
  47. #include <Windows.h>
  48.  
  49. //-----------------------------------------------------------------------
  50. // Constants
  51.  
  52. // Apple menu items
  53. enum
  54. {
  55.     kAboutItem = 1
  56. };
  57.  
  58. // File menu items
  59. enum
  60. {
  61.     kQuitItem = 1
  62. };
  63.  
  64. // Edit menu items
  65. enum
  66. {
  67.     kUndoItem = 1,
  68.     kCutItem = 3,
  69.     kCopyItem,
  70.     kPasteItem,
  71.     kClearItem
  72. };
  73.  
  74. // Test menu items
  75. enum
  76. {
  77.     kNewPrefsFileItem = 1,
  78.     kDeletePrefsFileItem,
  79.     kDeletePrefsFolderItem,
  80.     kGetPrefsFileVers1Item = 5,
  81.     kSetPrefsFileVers1Item,
  82.     kGetPrefsFileVers2Item,
  83.     kSetPrefsFileVers2Item,
  84.     kReadPrefsItem = 10,
  85.     kWritePrefsItem,
  86.     kDeletePrefsItem
  87. };
  88.  
  89. // About box dialog DITL items
  90. enum
  91. {
  92.     kAboutOKButton = 1,
  93.     kAboutOKButtonOutline
  94. };
  95.  
  96. //-----------------------------------------------------------------------
  97. // Globals
  98.  
  99. EventRecord    gTheEvent;
  100. MenuHandle    gAppleMenu;
  101. MenuHandle    gFileMenu;
  102. MenuHandle    gEditMenu;
  103. MenuHandle    gTestMenu;
  104. Boolean        gQuitFlag;
  105. Boolean        gDummyPrefsFileExists;
  106. Boolean        gBogusPrefsFileExists;
  107.  
  108. //-----------------------------------------------------------------------
  109. // Prototypes
  110.  
  111. static void
  112. DoInit (void);
  113.  
  114. static void
  115. DoMenuSetup (void);
  116.  
  117. static void
  118. HandleEvent (void);
  119.  
  120. static void
  121. HandleMouseDown (void);
  122.  
  123. static void
  124. AdjustMenus (void);
  125.  
  126. static void
  127. Enable (Handle menu, short item, Boolean ok);
  128.  
  129. static void
  130. HandleMenu (long menu);
  131.  
  132. static void
  133. DoAboutDialog (void);
  134.  
  135. static pascal void
  136. StdPrefsTesterDrawProc (DialogPtr theDialog, short theItemNum);
  137.  
  138. //-----------------------------------------------------------------------
  139.  
  140. main (void)
  141. {
  142.     // Init
  143.     DoInit();
  144.     DoMenuSetup();
  145.     
  146.     // Eat events until done
  147.     do
  148.     {
  149.         HandleEvent();
  150.     }
  151.     while (!gQuitFlag);
  152.     
  153.     // Take off, eh?
  154.     ExitToShell();
  155. }
  156.  
  157. //-----------------------------------------------------------------------
  158.  
  159. static void
  160. DoInit (void)
  161. {
  162.     OSErr    result = noErr;
  163.     
  164.     // Set up quit flag
  165.     gQuitFlag = false;
  166.     
  167.     // MacMantra™
  168.     MaxApplZone();
  169.     InitGraf (&qd.thePort);
  170.     InitFonts();
  171.     FlushEvents (everyEvent, 0);
  172.     InitWindows();
  173.     InitMenus();
  174.     TEInit();
  175.     InitDialogs (0L);
  176.     InitCursor();
  177.     MoreMasters();
  178.     MoreMasters();
  179.     MoreMasters();
  180.     MoreMasters();
  181.     
  182.     // Do our test prefs files exist?
  183.     gDummyPrefsFileExists = PreferencesFileExists (kDummyStdPrefsTesterCreator, 
  184.         kDummyPrefsFileType);
  185.     gBogusPrefsFileExists = PreferencesFileExists (kDummyStdPrefsTesterCreator,
  186.         kBogusPrefsFileType);
  187. }
  188.  
  189. //-----------------------------------------------------------------------
  190.  
  191. static void
  192. DoMenuSetup (void)
  193. {    
  194.     Handle    theMenuBar = GetNewMBar (kMenuBarID);
  195.     
  196.     // Set up our menus
  197.     SetMenuBar (theMenuBar);
  198.     gAppleMenu = GetMHandle (kAppleID);
  199.     gFileMenu = GetMHandle (kFileID);
  200.     gEditMenu = GetMHandle (kEditID);
  201.     gTestMenu = GetMHandle (kTestID);
  202.     AddResMenu (gAppleMenu, 'DRVR');
  203.     DrawMenuBar();
  204. }
  205.  
  206. //-----------------------------------------------------------------------
  207.  
  208. static void
  209. HandleEvent (void)
  210. {
  211.     Boolean    ok = false;
  212.  
  213.     // Do system stuff
  214.     HiliteMenu (0);
  215.     SystemTask();
  216.     
  217.     // Suck an event
  218.     ok = WaitNextEvent (everyEvent, &gTheEvent, 0, 0);
  219.     if (ok)
  220.     {
  221.         // What was it?
  222.         switch (gTheEvent.what)
  223.         {
  224.             case mouseDown:    // Handle a mouse down
  225.             {
  226.                 HandleMouseDown();
  227.                 break;
  228.             }
  229.             case keyDown:    // Handle command key equivalents
  230.             case autoKey:
  231.             {
  232.                 char    theChar = gTheEvent.message & charCodeMask;
  233.                 long    theMenu = MenuKey (theChar);
  234.  
  235.                 HandleMenu (theMenu);                
  236.                 break;
  237.             }
  238.             default:    // For the purposes of testing,
  239.             {            // we don't really care about any other events
  240.                 break;
  241.             }
  242.         }
  243.     }
  244. }
  245.  
  246. //-----------------------------------------------------------------------
  247.  
  248. static void
  249. HandleMouseDown (void)
  250. {    
  251.     WindowPtr    theWindow;
  252.     short        windowCode = FindWindow (gTheEvent.where, &theWindow);
  253.     
  254.     // Where was the mouse down?
  255.     switch (windowCode)
  256.     {
  257.         case inSysWindow:    // In a system window
  258.         { 
  259.             SystemClick (&gTheEvent, theWindow);
  260.             break;
  261.         }
  262.         case inMenuBar:        // In our menu bar
  263.         {
  264.             AdjustMenus();
  265.             HandleMenu (0L);
  266.             break;
  267.         }
  268.         default:
  269.         {
  270.             break;
  271.         }
  272.     }
  273. }
  274.  
  275. //-----------------------------------------------------------------------
  276.  
  277. static void
  278. AdjustMenus (void)
  279. {
  280.     register WindowPeek    wp = nil;
  281.     short                kind = 0;
  282.     Boolean                DA = false;
  283.     
  284.     // What kind of window is frontmost?
  285.     wp = (WindowPeek) FrontWindow();
  286.     kind = wp ? wp->windowKind : 0;
  287.     DA = kind < 0;
  288.     
  289.     // Set our menu item states appropriately
  290.     
  291.     // Apple menu
  292.     Enable ((Handle) gAppleMenu, kAboutItem, true);    
  293.     
  294.     // File menu
  295.     Enable ((Handle) gFileMenu, kQuitItem, true);
  296.  
  297.     // Edit menu
  298.     Enable ((Handle) gEditMenu, 1, DA);
  299.     Enable ((Handle) gEditMenu, 3, DA);
  300.     Enable ((Handle) gEditMenu, 4, DA);
  301.     Enable ((Handle) gEditMenu, 5, DA);
  302.     Enable ((Handle) gEditMenu, 6, DA);
  303.     
  304.     // Test menu
  305.     Enable ((Handle) gTestMenu, kNewPrefsFileItem, 
  306.         !(gDummyPrefsFileExists && gBogusPrefsFileExists));
  307.     Enable ((Handle) gTestMenu, kDeletePrefsFileItem, 
  308.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  309.     Enable ((Handle) gTestMenu, kDeletePrefsFolderItem, 
  310.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  311.     Enable ((Handle) gTestMenu, kGetPrefsFileVers1Item, 
  312.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  313.     Enable ((Handle) gTestMenu, kSetPrefsFileVers1Item, 
  314.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  315.     Enable ((Handle) gTestMenu, kGetPrefsFileVers2Item, 
  316.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  317.     Enable ((Handle) gTestMenu, kSetPrefsFileVers2Item, 
  318.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  319.     Enable ((Handle) gTestMenu, kReadPrefsItem, 
  320.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  321.     Enable ((Handle) gTestMenu, kWritePrefsItem, 
  322.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  323.     Enable ((Handle) gTestMenu, kDeletePrefsItem, 
  324.         (gDummyPrefsFileExists && gBogusPrefsFileExists));
  325.     
  326.     // Draw the menu bar
  327.     DrawMenuBar();
  328. }
  329.  
  330. //-----------------------------------------------------------------------
  331.  
  332. static void
  333. Enable (Handle menu, short item, Boolean ok)
  334. {
  335.     // Utility routine to enable and disable menu items
  336.     if (ok)
  337.     {
  338.         EnableItem ((MenuHandle) menu, item);
  339.     }
  340.     else
  341.     {
  342.         DisableItem ((MenuHandle) menu, item);
  343.     }
  344. }
  345.  
  346. //-----------------------------------------------------------------------
  347.  
  348. static void
  349. HandleMenu (long theMenu)
  350. {    
  351.     long    mSelect;
  352.     short    menuID;
  353.     short    menuItem;
  354.     
  355.     // Did we get a menu?
  356.     if (theMenu == 0L)
  357.     {
  358.         // Nope, get it from menu select
  359.         mSelect = MenuSelect (gTheEvent.where);
  360.     }
  361.     else
  362.     {
  363.         // Yep, use it
  364.         mSelect = theMenu;
  365.     }
  366.     
  367.     // Decode it
  368.     menuID = HiWord (mSelect);
  369.     menuItem = LoWord (mSelect);
  370.     
  371.     // Which menu is it?
  372.     switch (menuID)
  373.     {
  374.         // Apple menu
  375.         case kAppleID:
  376.         {
  377.             if (menuItem == kAboutItem)
  378.             {
  379.                 DoAboutDialog();
  380.             }
  381.             else    // It's a DA
  382.             {
  383.                 Str255    name;
  384.                 GrafPtr    savedPort;
  385.                 
  386.                 // Open the DA
  387.                 GetPort (&savedPort);
  388.                 GetItem (gAppleMenu, menuItem, name);
  389.                 OpenDeskAcc (name);
  390.                 SetPort (savedPort);
  391.             }
  392.             break;
  393.         }
  394.         
  395.         // File menu
  396.         case kFileID:
  397.         {
  398.             if (menuItem == kQuitItem)
  399.             {
  400.                 // Set quit flag
  401.                 gQuitFlag = true;
  402.             }
  403.             break;
  404.         }
  405.         
  406.         // Edit menu
  407.         case kEditID:
  408.         {
  409.             if (!SystemEdit (menuItem - 1))
  410.             {
  411.                 // We don't really do anything here - feel free to implement something
  412.                 // yourself if you want
  413.                 SysBeep(5);
  414.             }
  415.             break;
  416.         }
  417.         
  418.         // Test menu
  419.         case kTestID:
  420.         {
  421.             Str255        versNumStr = "\p1.0.1d1";
  422.             Str255        companyStr = "\p1.0.1d1 (US), © Apple Computer, Inc. 1993-94";
  423.             Str255        fileSetStr = "\p(for StdPrefsTester 1.0)";
  424.             Str255        shortVersionStr;
  425.             Str255        longVersionStr;
  426.             NumVersion    numVersion;
  427.             Handle        prefHdl;
  428.             OSErr        result = noErr;
  429.             short        regionCode;
  430.             short        id;
  431.             short        dummyFRefNum;
  432.             short        bogusFRefNum;
  433.             
  434.             // What menu item was it?
  435.             switch (menuItem)
  436.             {
  437.                 case kNewPrefsFileItem:    // New preferences file
  438.                 {
  439.                     // Does "Dummy Prefs" exist?
  440.                     if (!gDummyPrefsFileExists)
  441.                     {
  442.                         // Nope - Create "Dummy Prefs" in "Dummy Prefs ƒ" in 
  443.                         // either Preferences folder or System Folder
  444.                         result = NewPreferencesFile (kDummyStdPrefsTesterCreator,
  445.                             kDummyPrefsFileType, "\pDummy Prefs", "\pDummy Prefs ƒ",
  446.                             "\pthe application StdPrefsTester");
  447.                         if (result == noErr)
  448.                         {
  449.                             gDummyPrefsFileExists = true;
  450.                         }
  451.                     }
  452.                     
  453.                     // Does "Bogus Prefs" exist?
  454.                     if (!gBogusPrefsFileExists)
  455.                     {
  456.                         // Nope - Create "Bogus Prefs" in either Preferences 
  457.                         // folder or System Folder
  458.                         result = NewPreferencesFile (kDummyStdPrefsTesterCreator,
  459.                             kBogusPrefsFileType,"\pBogus Prefs", nil,
  460.                             "\pthe application StdPrefsTester");
  461.                         if (result == noErr)
  462.                         {
  463.                             gBogusPrefsFileExists = true;
  464.                         }
  465.                     }
  466.                     break;
  467.                 }
  468.                 case kDeletePrefsFileItem:    // Delete preferences file
  469.                 {
  470.                     // Delete "Dummy Prefs"
  471.                     result = DeletePreferencesFile (kDummyStdPrefsTesterCreator, 
  472.                         kDummyPrefsFileType);
  473.                     if (result == noErr)
  474.                     {
  475.                         gDummyPrefsFileExists = false;
  476.                     }
  477.                     
  478.                     // Delete "Bogus Prefs"
  479.                     result = DeletePreferencesFile (kDummyStdPrefsTesterCreator, 
  480.                         kBogusPrefsFileType);
  481.                     if (result == noErr)
  482.                     {
  483.                         gBogusPrefsFileExists = false;
  484.                     }
  485.                     break;
  486.                 }
  487.                 case kDeletePrefsFolderItem:    // Delete preferences folder
  488.                 {
  489.                     // Delete "Dummy Prefs ƒ" folder, along with its contents
  490.                     result = DeletePreferencesFolder ("\pDummy Prefs ƒ");
  491.                     if (result == noErr)
  492.                     {
  493.                         gDummyPrefsFileExists = false;
  494.                     }
  495.                     break;
  496.                 }
  497.                 case kGetPrefsFileVers1Item:    // Get preferences file version 1 resource
  498.                 {
  499.                     // Open "Dummy Prefs"
  500.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kDummyPrefsFileType,
  501.                         &dummyFRefNum);
  502.                     if (result == noErr)
  503.                     {
  504.                         // Get the contents of the vers 1 resource
  505.                         result = GetPreferencesFileVersion (dummyFRefNum, kVers1, &numVersion, 
  506.                             ®ionCode, shortVersionStr, longVersionStr);
  507.                             
  508.                         // Close "Dummy Prefs"
  509.                         result = ClosePreferencesFile (dummyFRefNum);
  510.                     }
  511.                         
  512.                     // Open "Bogus Prefs"
  513.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kBogusPrefsFileType, 
  514.                         &bogusFRefNum);
  515.                     if (result == noErr)
  516.                     {
  517.                         // Get the contents of the vers 1 resource
  518.                         result = GetPreferencesFileVersion (bogusFRefNum, kVers1, &numVersion, 
  519.                             ®ionCode, shortVersionStr, longVersionStr);
  520.                             
  521.                         // Close "Bogus Prefs"
  522.                         result = ClosePreferencesFile (bogusFRefNum);
  523.                     }
  524.                     break;
  525.                 }
  526.                 case kSetPrefsFileVers1Item:    // Set preferences file version 1 resource
  527.                 {
  528.                     numVersion.majorRev = 0x01;
  529.                     numVersion.minorAndBugRev = 0x01;
  530.                     numVersion.stage = developStage;
  531.                     numVersion.nonRelRev = 0x01;
  532.                     regionCode = GetEnvirons (smRegionCode);    // Does this work for System 6?
  533.                     
  534.                     // Open "Dummy Prefs"
  535.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kDummyPrefsFileType,
  536.                         &dummyFRefNum);
  537.                     if (result == noErr)
  538.                     {
  539.                         // Set the contents of the vers 1 resource
  540.                         result = SetPreferencesFileVersion (dummyFRefNum, kVers1, &numVersion, 
  541.                             regionCode, versNumStr, companyStr);
  542.                             
  543.                         // Close "Dummy Prefs"
  544.                         result = ClosePreferencesFile (dummyFRefNum);
  545.                     }
  546.  
  547.                     // Open "Bogus Prefs"
  548.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kBogusPrefsFileType, 
  549.                         &bogusFRefNum);
  550.                     if (result == noErr)
  551.                     {
  552.                         // Set the contents of the vers 1 resource
  553.                         result = SetPreferencesFileVersion (bogusFRefNum, kVers1, &numVersion, 
  554.                             regionCode, versNumStr, companyStr);
  555.                             
  556.                         // Close "Bogus Prefs"
  557.                         result = ClosePreferencesFile (bogusFRefNum);
  558.                     }
  559.                     break;
  560.                 }
  561.                 case kGetPrefsFileVers2Item:    // Get preferences file version 2 resource
  562.                 {
  563.                     // Open "Dummy Prefs"
  564.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kDummyPrefsFileType,
  565.                         &dummyFRefNum);
  566.                     if (result == noErr)
  567.                     {
  568.                         // Get the contents of the vers 2 resource
  569.                         result = GetPreferencesFileVersion (dummyFRefNum, kVers2, &numVersion, 
  570.                             ®ionCode, shortVersionStr, longVersionStr);
  571.                             
  572.                         // Close "Dummy Prefs"
  573.                         result = ClosePreferencesFile (dummyFRefNum);
  574.                     }
  575.  
  576.                     // Open "Bogus Prefs"
  577.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kBogusPrefsFileType, 
  578.                         &bogusFRefNum);
  579.                     if (result == noErr)
  580.                     {
  581.                         // Get the contents of the vers 2 resource
  582.                         result = GetPreferencesFileVersion (bogusFRefNum, kVers2, &numVersion, 
  583.                             ®ionCode, shortVersionStr, longVersionStr);
  584.                             
  585.                         // Close "Bogus Prefs"
  586.                         result = ClosePreferencesFile (bogusFRefNum);
  587.                     }
  588.                     break;
  589.                 }
  590.                 case kSetPrefsFileVers2Item:    // Set preferences file version 2 resource
  591.                 {
  592.                     numVersion.majorRev = 0x01;
  593.                     numVersion.minorAndBugRev = 0x01;
  594.                     numVersion.stage = developStage;
  595.                     numVersion.nonRelRev = 0x01;
  596.                     regionCode = GetEnvirons (smRegionCode);    // Does this work for System 6?
  597.  
  598.                     // Open "Dummy Prefs"
  599.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kDummyPrefsFileType,
  600.                         &dummyFRefNum);
  601.                     if (result == noErr)
  602.                     {
  603.                         // Set the contents of the vers 2 resource
  604.                         result = SetPreferencesFileVersion (dummyFRefNum, kVers2, &numVersion, 
  605.                             regionCode, versNumStr, fileSetStr);
  606.                             
  607.                         // Close "Dummy Prefs"
  608.                         result = ClosePreferencesFile (dummyFRefNum);
  609.                     }
  610.                     
  611.                     // Open "Bogus Prefs"
  612.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, kBogusPrefsFileType, 
  613.                         &bogusFRefNum);
  614.                     if (result == noErr)
  615.                     {
  616.                         // Set the contents of the vers 2 resource
  617.                         result = SetPreferencesFileVersion (bogusFRefNum, kVers2, &numVersion, 
  618.                             regionCode, versNumStr, fileSetStr);
  619.                             
  620.                         // Close "Bogus Prefs"
  621.                         result = ClosePreferencesFile (bogusFRefNum);
  622.                     }
  623.                     break;
  624.                 }
  625.                 case kReadPrefsItem:    // Read preference
  626.                 {
  627.                     // Open "Dummy Prefs"
  628.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  629.                         kDummyPrefsFileType, &dummyFRefNum);
  630.                     if (result == noErr)
  631.                     {
  632.                         // Read the first resource of type 'myPf'
  633.                         result = ReadPreference (dummyFRefNum, 'myPf', nil, &prefHdl);
  634.                         
  635.                         // Read the first resource of type 'myPf' and return its
  636.                         // resource ID
  637.                         id = 0;
  638.                         result = ReadPreference (dummyFRefNum, 'myPf', &id, &prefHdl);
  639.                         
  640.                         // Read the resource of type 'myPf' and ID 128
  641.                         id = 128;
  642.                         result = ReadPreference (dummyFRefNum, 'myPf', &id, &prefHdl);
  643.                         
  644.                         // Close "Dummy Prefs"
  645.                         result = ClosePreferencesFile (dummyFRefNum);
  646.                     }
  647.                     
  648.                     // Open "Bogus Prefs"
  649.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  650.                         kBogusPrefsFileType, &bogusFRefNum);
  651.                     if (result == noErr)
  652.                     {
  653.                         // Read the first resource of type 'myPf'
  654.                         result = ReadPreference (bogusFRefNum, 'myPf', nil, &prefHdl);
  655.                         
  656.                         // Read the first resource of type 'myPf' and return its
  657.                         // resource ID
  658.                         id = 0;
  659.                         result = ReadPreference (bogusFRefNum, 'myPf', &id, &prefHdl);
  660.  
  661.                         // Read the resource of type 'myPf' and ID 128
  662.                         id = 128;
  663.                         result = ReadPreference (bogusFRefNum, 'myPf', &id, &prefHdl);
  664.                         
  665.                         // Close "Bogus Prefs"
  666.                         result = ClosePreferencesFile (bogusFRefNum);
  667.                     }
  668.                     break;
  669.                 }
  670.                 case kWritePrefsItem:    // Write preference
  671.                 {
  672.                     // Create a handle for our preference data
  673.                     prefHdl = NewHandle (sizeof (long));
  674.                     if (prefHdl != nil)
  675.                     {
  676.                         // Open "Dummy Prefs"
  677.                         result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  678.                             kDummyPrefsFileType, &dummyFRefNum);
  679.                         if (result == noErr)
  680.                         {
  681.                             // Set the contents of the preference data to 10
  682.                             **((long**)prefHdl) = 10L;
  683.                             
  684.                             // Write the preference data to "Dummy Prefs"
  685.                             result = WritePreference (dummyFRefNum, 'myPf', nil, prefHdl);
  686.                             
  687.                             // Set the contents of the preference data to 20
  688.                             **((long**)prefHdl) = 20L;
  689.                             
  690.                             // Write the preference data to "Dummy Prefs" and return
  691.                             // its resource ID in the file
  692.                             id = 0;
  693.                             result = WritePreference (dummyFRefNum, 'myPf', &id, prefHdl);
  694.                             
  695.                             // Set the contents of the preference data to 30
  696.                             **((long**)prefHdl) = 30L;
  697.                             
  698.                             // Write the preference data to "Dummy Prefs" with an ID
  699.                             // of 128
  700.                             id = 128;
  701.                             result = WritePreference (dummyFRefNum, 'myPf', &id, prefHdl);
  702.                             
  703.                             // Close "Dummy Prefs"
  704.                             result = ClosePreferencesFile (dummyFRefNum);
  705.                         }
  706.     
  707.                         // Open "Bogus Prefs"
  708.                         result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  709.                             kBogusPrefsFileType, &bogusFRefNum);
  710.                         if (result == noErr)
  711.                         {
  712.                             // Set the contents of the preference data to 10
  713.                             **((long**)prefHdl) = 10L;
  714.                             
  715.                             // Write the preference data to "Bogus Prefs"
  716.                             result = WritePreference (bogusFRefNum, 'myPf', nil, prefHdl);
  717.                             
  718.                             // Set the contents of the preference data to 20
  719.                             **((long**)prefHdl) = 20L;
  720.                             
  721.                             // Write the preference data to "Bogus Prefs" and return
  722.                             // its resource ID in the file
  723.                             id = 0;
  724.                             result = WritePreference (bogusFRefNum, 'myPf', &id, prefHdl);
  725.                             
  726.                             // Set the contents of the preference data to 30
  727.                             **((long**)prefHdl) = 30L;
  728.                             
  729.                             // Write the preference data to "Bogus Prefs" with an ID
  730.                             // of 128
  731.                             id = 128;
  732.                             result = WritePreference (bogusFRefNum, 'myPf', &id, prefHdl);
  733.                             
  734.                             // Close "Bogus Prefs"
  735.                             result = ClosePreferencesFile (bogusFRefNum);
  736.                         }
  737.                         
  738.                         // Clean up
  739.                         DisposeHandle (prefHdl);
  740.                     }
  741.                     break;
  742.                 }
  743.                 case kDeletePrefsItem:    // Delete preference
  744.                 {
  745.                     // Open "Dummy Prefs"
  746.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  747.                         kDummyPrefsFileType, &dummyFRefNum);
  748.                     if (result == noErr)
  749.                     {
  750.                         // Delete the preference data of type 'myPf' with ID 128
  751.                         result = DeletePreference (dummyFRefNum, 'myPf', 128);
  752.                         
  753.                         // Delete the first preference data found of type 'myPf'
  754.                         result = DeletePreference (dummyFRefNum, 'myPf', 0);
  755.                         
  756.                         // Close "Dummy Prefs"
  757.                         result = ClosePreferencesFile (dummyFRefNum);
  758.                     }
  759.  
  760.                     // Open "Bogus Prefs"
  761.                     result = OpenPreferencesFile (kDummyStdPrefsTesterCreator, 
  762.                         kBogusPrefsFileType, &bogusFRefNum);
  763.                     if (result == noErr)
  764.                     {
  765.                         // Delete the preference data of type 'myPf' with ID 128
  766.                         result = DeletePreference (bogusFRefNum, 'myPf', 128);
  767.                         
  768.                         // Delete the first preference data found of type 'myPf'
  769.                         result = DeletePreference (bogusFRefNum, 'myPf', 0);
  770.                         
  771.                         // Close "Bogus Prefs"
  772.                         result = ClosePreferencesFile (bogusFRefNum);
  773.                     }
  774.                     break;
  775.                 }
  776.                 default:
  777.                 {
  778.                     break;
  779.                 }
  780.             }
  781.             break;
  782.         }
  783.         default:
  784.         {
  785.             break;
  786.         }
  787.     }
  788. }
  789.  
  790. //-----------------------------------------------------------------------
  791.  
  792. static void
  793. DoAboutDialog (void)
  794. {
  795.     DialogPtr    aboutDialog = GetNewDialog (kAboutDialogID, nil, (WindowPtr)-1L);
  796.  
  797.     // Do the boring about dialog
  798.     if (aboutDialog != nil)
  799.     {
  800.         Rect        itemRect;
  801.         Handle        itemHandle;
  802.         short        itemHit;
  803.         short        itemType;
  804.         
  805.         GetDItem (aboutDialog, kAboutOKButtonOutline, &itemType, &itemHandle, &itemRect);
  806.         SetDItem (aboutDialog, kAboutOKButtonOutline, itemType, 
  807.             (Handle) StdPrefsTesterDrawProc, &itemRect);
  808.             
  809.         ShowWindow (aboutDialog);
  810.         
  811.         do
  812.         {
  813.             ModalDialog (nil, &itemHit);
  814.         }
  815.         while (itemHit != kAboutOKButton);
  816.         
  817.         DisposDialog (aboutDialog);
  818.     }
  819. }
  820.  
  821. //-----------------------------------------------------------------------
  822.  
  823. static pascal void
  824. StdPrefsTesterDrawProc (DialogPtr theDialog, short theItemNum)
  825. {
  826.     PenState    thePenState;
  827.     Rect        itemRect;
  828.     Handle        itemHandle;
  829.     short        itemType;
  830.     
  831.     // Save the pen
  832.     GetPenState (&thePenState);
  833.     
  834.     // Get the item rect
  835.     GetDItem (theDialog, theItemNum, &itemType, &itemHandle, &itemRect);
  836.     
  837.     // What item do we need to draw?
  838.     switch (theItemNum)
  839.     {
  840.         case kAboutOKButtonOutline:
  841.         {
  842.             // Draw the OK button outline
  843.             PenNormal();
  844.             PenMode (patCopy);
  845.             PenSize (3, 3);
  846.             InsetRect (&itemRect, -4, -4);
  847.             FrameRoundRect (&itemRect, 16, 16);
  848.             break;
  849.         }
  850.         default:
  851.         {
  852.             break;
  853.         }
  854.     }
  855.     
  856.     // Restore the pen
  857.     SetPenState (&thePenState);
  858. }
  859.  
  860. //-----------------------------------------------------------------------
  861.  
  862.